package com.hgl.bi.web.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hgl.bi.common.constant.ErrorCode;
import com.hgl.bi.common.model.dto.PageDTO;
import com.hgl.bi.common.model.vo.R;
import com.hgl.bi.common.utils.AssertUtil;
import com.hgl.bi.common.utils.ConvertUtil;
import com.hgl.bi.web.entity.RoleEntity;
import com.hgl.bi.web.model.dto.RolePmtDto;
import com.hgl.bi.web.model.dto.RoleSaveDto;
import com.hgl.bi.web.service.RoleService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @program: BI
 * @description: 角色管理控制层
 * @author: hgl
 * @create: 2025-02-15 00:26
 */
@Tag(name = "角色管理模块")
@RestController
public class RoleController {

    @Autowired
    private RoleService roleService;

    /**
     * 获取所有角色
     * @return 角色列表
     * @author hgl
     */
    @Operation(summary = "查询所有角色", tags = "角色管理模块")
    @GetMapping("/role/list/all")
    public R<List<RoleEntity>> getAllRoles() {
        List<RoleEntity> roles = roleService.list();
        return R.success(roles);
    }

    /**
     * 分配角色权限
     * @param rolePmtDto 角色权限信息
     * @return R<String>
     * @author hgl
     */
    @Operation(summary = "分配权限", tags = "角色管理模块")
    @PutMapping("/role/permission")
    public R<String> awardPermission(@RequestBody RolePmtDto rolePmtDto) {
        // 非空校验
        AssertUtil.notNull(rolePmtDto, ErrorCode.REQUEST_PARAM_ERROR);
        // 分配权限
        roleService.awardPermission(rolePmtDto);
        return R.ok("分配成功");
    }


    /**
     * 获取角色权限
     * @param id 角色ID
     * @return 角色权限
     * @author hgl
     */
    @Operation(summary = "查询角色权限", tags = "角色管理模块")
    @GetMapping("/role/permissions/{id}")
    public R<List<Long>> getRolePermissions(@PathVariable Long id) {
        // 非空校验
        AssertUtil.notNull(id, ErrorCode.REQUEST_PARAM_ERROR);
        List<Long> permissions = roleService.getRolePermissions(id);
        return R.success(permissions);
    }

    /**
     * 删除角色权限
     * @param rolePmtDto 角色权限信息
     * @return 提示信息
     */
    @Operation(summary = "删除权限", tags = "角色管理模块")
    @DeleteMapping("/role/remove/permission")
    public R<String> removeRolePermission(@RequestBody RolePmtDto rolePmtDto) {
        // 非空校验
        AssertUtil.notNull(rolePmtDto, ErrorCode.REQUEST_PARAM_ERROR);
        // 删除权限
        roleService.removeRolePermission(rolePmtDto);
        return R.ok("删除成功");
    }

    /**
     * 分页查询角色列表
     *
     * @param pageDto 分页信息
     * @return 角色分页信息
     * @author hgl
     */
    @Operation(summary = "查询角色列表", tags = "角色管理模块")
    @GetMapping("/role/list")
    public R<Page<RoleEntity>> listRoles(@ParameterObject PageDTO pageDto) {
        // 非空校验
        AssertUtil.notNull(pageDto, ErrorCode.REQUEST_PARAM_ERROR);
        // 分页查询
        Page<RoleEntity> page = new Page<>(pageDto.getPage(), pageDto.getSize());
        QueryWrapper<RoleEntity> wrapper = new QueryWrapper<>();
        if (pageDto.getKeyword() != null && !pageDto.getKeyword().isEmpty()) wrapper
                .like("role_name", pageDto.getKeyword())
                .or().like("role_code", pageDto.getKeyword());
        Page<RoleEntity> rolePage = roleService.page(page, wrapper);
        return R.success(rolePage);
    }

    /**
     * 获取角色详情
     *
     * @param id 角色ID
     * @return 角色信息
     * @author hgl
     */
    @Operation(summary = "查询角色详情", tags = "角色管理模块")
    @GetMapping("/role/info/{id}")
    public R<RoleEntity> getRoleInfo(@PathVariable Long id) {
        // 非空校验
        AssertUtil.notNull(id, ErrorCode.REQUEST_PARAM_ERROR);
        // 查询角色
        RoleEntity role = roleService.getById(id);
        return R.success(role);
    }

    /**
     * 更新角色信息
     *
     * @param role 角色信息
     * @return R<String>
     * @author hgl
     */
    @Operation(summary = "更新角色信息", tags = "角色管理模块")
    @PostMapping("/role/update")
    public R<String> updateRoleInfo(@RequestBody RoleEntity role) {
        // 非空校验
        AssertUtil.notNull(role, ErrorCode.REQUEST_PARAM_ERROR);
        // 更新角色
        UpdateWrapper<RoleEntity> wrapper = new UpdateWrapper<RoleEntity>()
                .eq("id", role.getId());
        if (role.getRoleName() != null) wrapper.set("role_name", role.getRoleName());
        if (role.getRoleCode() != null) wrapper.set("role_code", role.getRoleCode());
        if (role.getRoleDesc() != null) wrapper.set("role_desc", role.getRoleDesc());
        boolean updated = roleService.update(wrapper);
        AssertUtil.isTrue(updated, ErrorCode.UPDATE_FALSE);
        return R.ok("更新成功");
    }

    /**
     * 保存角色信息
     *
     * @param role 角色信息
     * @return R<String>
     * @author hgl
     */
    @Operation(summary = "保存角色信息", tags = "角色管理模块")
    @PutMapping("/role/save")
    public R<String> saveRoleInfo(@RequestBody RoleSaveDto role) {
        // 非空校验
        AssertUtil.notNull(role, ErrorCode.REQUEST_PARAM_ERROR);
        // 保存角色
        RoleEntity roleEntity = ConvertUtil.convertObject(role, RoleEntity.class, null);
        boolean saved = roleService.save(roleEntity);
        AssertUtil.isTrue(saved, ErrorCode.SAVE_FALSE);
        return R.ok("保存成功");
    }

    /**
     * 删除角色信息
     *
     * @param id 角色ID
     * @return R<String>
     * @author hgl
     */
    @Operation(summary = "删除角色信息", tags = "角色管理模块")
    @DeleteMapping("/role/remove/{id}")
    public R<String> removeRoleInfo(@PathVariable Long id) {
        // 非空校验
        AssertUtil.notNull(id, ErrorCode.REQUEST_PARAM_ERROR);
        // 删除用户
        boolean removed = roleService.removeById(id);
        AssertUtil.isTrue(removed, ErrorCode.REMOVE_FALSE);
        return R.ok("删除成功");
    }
}
